/*
 * Copyright (c) 2011, the Dart project authors.
 * 
 * Licensed under the Eclipse Public License v1.0 (the "License"); you may not use this file except
 * in compliance with the License. You may obtain a copy of the License at
 * 
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Unless required by applicable law or agreed to in writing, software distributed under the License
 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
 * or implied. See the License for the specific language governing permissions and limitations under
 * the License.
 */
package com.google.dart.tools.ui.internal.text.functions;

import org.eclipse.core.runtime.Assert;
import org.eclipse.jface.text.rules.ICharacterScanner;
import org.eclipse.jface.text.rules.IRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.IWordDetector;
import org.eclipse.jface.text.rules.Token;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * An implementation of <code>IRule</code> capable of detecting words.
 * <p>
 * Word rules also allow for the association of tokens with specific words. That is, not only can
 * the rule be used to provide tokens for exact matches, but also for the generalized notion of a
 * word in the context in which it is used. A word rules uses a word detector to determine what a
 * word is.
 * </p>
 * <p>
 * This word rule allows a word detector to be shared among different word matchers. Its up to the
 * word matchers to decide if a word matches and, in this a case, which token is associated with
 * that word.
 * </p>
 * 
 * @see IWordDetector
 */
public class CombinedWordRule implements IRule {

  /**
   * Character buffer, mutable <b>or</b> suitable for use as key in hash maps.
   */
  public static class CharacterBuffer {

    /** Buffer content */
    private char[] fContent;
    /** Buffer content size */
    private int fLength = 0;

    /** Is hash code cached? */
    private boolean fIsHashCached = false;
    /** The hash code */
    private int fHashCode;

    /**
     * Initialize with the given capacity.
     * 
     * @param capacity the initial capacity
     */
    public CharacterBuffer(int capacity) {
      fContent = new char[capacity];
    }

    /**
     * Initialize with the given content.
     * 
     * @param content the initial content
     */
    public CharacterBuffer(String content) {
      fContent = content.toCharArray();
      fLength = content.length();
    }

    /**
     * Appends the given character to the buffer.
     * 
     * @param c the character
     */
    public void append(char c) {
      fIsHashCached = false;
      if (fLength == fContent.length) {
        char[] old = fContent;
        fContent = new char[old.length << 1];
        System.arraycopy(old, 0, fContent, 0, old.length);
      }
      fContent[fLength++] = c;
    }

    /**
     * Returns the character at the given position.
     * 
     * @param i the position
     * @return the character at position <code>i</code>
     */
    public char charAt(int i) {
      return fContent[i];
    }

    /**
     * Empties this buffer.
     */
    public void clear() {
      fIsHashCached = false;
      fLength = 0;
    }

    /*
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(Object obj) {
      if (obj == this) {
        return true;
      }
      if (!(obj instanceof CharacterBuffer)) {
        return false;
      }
      CharacterBuffer buffer = (CharacterBuffer) obj;
      int length = buffer.length();
      if (length != fLength) {
        return false;
      }
      for (int i = 0; i < length; i++) {
        if (buffer.charAt(i) != fContent[i]) {
          return false;
        }
      }
      return true;
    }

    /**
     * Is the content equal to the given string?
     * 
     * @param string the string
     * @return <code>true</code> iff the content is the same character sequence as in the string
     */
    public boolean equals(String string) {
      int length = string.length();
      if (length != fLength) {
        return false;
      }
      for (int i = 0; i < length; i++) {
        if (string.charAt(i) != fContent[i]) {
          return false;
        }
      }
      return true;
    }

    /*
     * @see java.lang.Object#hashCode()
     */
    @Override
    public int hashCode() {
      if (fIsHashCached) {
        return fHashCode;
      }

      int hash = 0;
      for (int i = 0, n = fLength; i < n; i++) {
        hash = 29 * hash + fContent[i];
      }
      fHashCode = hash;
      fIsHashCached = true;
      return hash;
    }

    /**
     * Returns the length of the content.
     * 
     * @return the length
     */
    public int length() {
      return fLength;
    }

    /**
     * Returns the content as string.
     * 
     * @return the content
     */
    @Override
    public String toString() {
      return new String(fContent, 0, fLength);
    }
  }

  /**
   * Word matcher, that associates matched words with tokens.
   */
  public static class WordMatcher {

    /** The table of predefined words and token for this matcher */
    private Map<CharacterBuffer, IToken> fWords = new HashMap<CharacterBuffer, IToken>();

    /**
     * Adds a word and the token to be returned if it is detected.
     * 
     * @param word the word this rule will search for, may not be <code>null</code>
     * @param token the token to be returned if the word has been found, may not be
     *          <code>null</code>
     */
    public void addWord(String word, IToken token) {
      Assert.isNotNull(word);
      Assert.isNotNull(token);

      fWords.put(new CharacterBuffer(word), token);
    }

    /**
     * Removes all words.
     */
    public void clearWords() {
      fWords.clear();
    }

    /**
     * Returns the token associated to the given word and the scanner state.
     * 
     * @param scanner the scanner
     * @param word the word
     * @return the token or <code>null</code> if none is associated by this matcher
     */
    public IToken evaluate(ICharacterScanner scanner, CharacterBuffer word) {
      IToken token = fWords.get(word);
      if (token != null) {
        return token;
      }
      return Token.UNDEFINED;
    }
  }

  /** Internal setting for the uninitialized column constraint */
  private static final int UNDEFINED = -1;

  /** The word detector used by this rule */
  private IWordDetector fDetector;
  /**
   * The default token to be returned on success and if nothing else has been specified.
   */
  private IToken fDefaultToken;
  /** The column constraint */
  private int fColumn = UNDEFINED;
  /** Buffer used for pattern detection */
  private CharacterBuffer fBuffer = new CharacterBuffer(16);

  /** List of word matchers */
  private List<WordMatcher> fMatchers = new ArrayList<WordMatcher>();

  /**
   * Creates a rule which, with the help of an word detector, will return the token associated with
   * the detected word. If no token has been associated, the scanner will be rolled back and an
   * undefined token will be returned in order to allow any subsequent rules to analyze the
   * characters.
   * 
   * @param detector the word detector to be used by this rule, may not be <code>null</code>
   * @see WordMatcher#addWord(String, IToken)
   */
  public CombinedWordRule(IWordDetector detector) {
    this(detector, null, Token.UNDEFINED);
  }

  /**
   * Creates a rule which, with the help of an word detector, will return the token associated with
   * the detected word. If no token has been associated, the specified default token will be
   * returned.
   * 
   * @param detector the word detector to be used by this rule, may not be <code>null</code>
   * @param defaultToken the default token to be returned on success if nothing else is specified,
   *          may not be <code>null</code>
   * @see WordMatcher#addWord(String, IToken)
   */
  public CombinedWordRule(IWordDetector detector, IToken defaultToken) {
    this(detector, null, defaultToken);
  }

  /**
   * Creates a rule which, with the help of an word detector, will return the token associated with
   * the detected word. If no token has been associated, the scanner will be rolled back and an
   * undefined token will be returned in order to allow any subsequent rules to analyze the
   * characters.
   * 
   * @param detector the word detector to be used by this rule, may not be <code>null</code>
   * @param matcher the initial word matcher
   * @see WordMatcher#addWord(String, IToken)
   */
  public CombinedWordRule(IWordDetector detector, WordMatcher matcher) {
    this(detector, matcher, Token.UNDEFINED);
  }

  /**
   * Creates a rule which, with the help of an word detector, will return the token associated with
   * the detected word. If no token has been associated, the specified default token will be
   * returned.
   * 
   * @param detector the word detector to be used by this rule, may not be <code>null</code>
   * @param matcher the initial word matcher
   * @param defaultToken the default token to be returned on success if nothing else is specified,
   *          may not be <code>null</code>
   * @see WordMatcher#addWord(String, IToken)
   */
  public CombinedWordRule(IWordDetector detector, WordMatcher matcher, IToken defaultToken) {

    Assert.isNotNull(detector);
    Assert.isNotNull(defaultToken);

    fDetector = detector;
    fDefaultToken = defaultToken;
    if (matcher != null) {
      addWordMatcher(matcher);
    }
  }

  /**
   * Adds the given matcher.
   * 
   * @param matcher the matcher
   */
  public void addWordMatcher(WordMatcher matcher) {
    fMatchers.add(matcher);
  }

  /*
   * @see IRule#evaluate(ICharacterScanner)
   */
  @Override
  public IToken evaluate(ICharacterScanner scanner) {
    int c = scanner.read();
    if (fDetector.isWordStart((char) c)) {
      if (fColumn == UNDEFINED || (fColumn == scanner.getColumn() - 1)) {

        fBuffer.clear();
        do {
          fBuffer.append((char) c);
          c = scanner.read();
        } while (c != ICharacterScanner.EOF && fDetector.isWordPart((char) c));
        scanner.unread();

        for (int i = 0, n = fMatchers.size(); i < n; i++) {
          IToken token = fMatchers.get(i).evaluate(scanner, fBuffer);
          if (!token.isUndefined()) {
            return token;
          }
        }

        if (fDefaultToken.isUndefined()) {
          unreadBuffer(scanner);
        }

        return fDefaultToken;
      }
    }

    scanner.unread();
    return Token.UNDEFINED;
  }

  /**
   * Sets a column constraint for this rule. If set, the rule's token will only be returned if the
   * pattern is detected starting at the specified column. If the column is smaller then 0, the
   * column constraint is considered removed.
   * 
   * @param column the column in which the pattern starts
   */
  public void setColumnConstraint(int column) {
    if (column < 0) {
      column = UNDEFINED;
    }
    fColumn = column;
  }

  /**
   * Returns the characters in the buffer to the scanner.
   * 
   * @param scanner the scanner to be used
   */
  private void unreadBuffer(ICharacterScanner scanner) {
    for (int i = fBuffer.length() - 1; i >= 0; i--) {
      scanner.unread();
    }
  }
}
